home *** CD-ROM | disk | FTP | other *** search
/ PC PowerPlay 58 / pcpp58a.iso / extras / quake 3 source / Q3A_ToolSource.exe / Main / MRU.CPP < prev    next >
Encoding:
C/C++ Source or Header  |  2001-01-02  |  18.6 KB  |  651 lines
  1. //*************************************************************
  2. //  File name: mru.c
  3. //
  4. //  Description:
  5. //
  6. //      Routines for MRU support
  7. //
  8. //  Development Team:
  9. //
  10. //      Gilles Vollant (100144.2636@compuserve.com) 
  11. //
  12. //*************************************************************
  13.  
  14. #include "stdafx.h"
  15. #include <windows.h>
  16. #include <windowsx.h>
  17. #include <string.h>
  18.  
  19. #include "mru.h"
  20. // CreateMruMenu  : MRUMENU constructor
  21. // wNbLruShowInit : nb of item showed in menu
  22. // wNbLruMenuInit : nb of item stored in memory
  23. // wMaxSizeLruItemInit : size max. of filename
  24.  
  25.  
  26. //*************************************************************
  27. //
  28. //  CreateMruMenu()
  29. //
  30. //  Purpose:
  31. //
  32. //              Allocate and Initialize an MRU and return a pointer on it
  33. //
  34. //
  35. //  Parameters:
  36. //
  37. //      WORD wNbLruShowInit -      Maximum number of item displayed on menu
  38. //      WORD wNbLruMenuInit -      Maximum number of item stored in memory
  39. //      WORD wMaxSizeLruItemInit - Maximum size of an item (ie size of pathname)
  40. //      WORD wIdMruInit -          ID of the first item in the menu (default:IDMRU)
  41. //
  42. //
  43. //  Return: (LPMRUMENU)
  44. //
  45. //      Pointer on a MRUMENU structure, used by other function
  46. //
  47. //
  48. //  Comments:
  49. //      wNbLruShowInit <= wNbLruMenuInit
  50. //
  51. //
  52. //  History:    Date       Author       Comment
  53. //              09/24/94   G. Vollant   Created
  54. //
  55. //*************************************************************
  56.  
  57. LPMRUMENU CreateMruMenu (WORD wNbLruShowInit,
  58.             WORD wNbLruMenuInit,WORD wMaxSizeLruItemInit,WORD wIdMruInit)
  59. {
  60. LPMRUMENU lpMruMenu;
  61.   lpMruMenu = (LPMRUMENU)GlobalAllocPtr(GHND,sizeof(MRUMENU));
  62.  
  63.   lpMruMenu->wNbItemFill = 0;                   
  64.   lpMruMenu->wNbLruMenu = wNbLruMenuInit;             
  65.   lpMruMenu->wNbLruShow = wNbLruShowInit;
  66.   lpMruMenu->wIdMru = wIdMruInit;
  67.   lpMruMenu->wMaxSizeLruItem = wMaxSizeLruItemInit;
  68.   lpMruMenu->lpMRU = (LPSTR)GlobalAllocPtr(GHND,
  69.                       lpMruMenu->wNbLruMenu*(UINT)lpMruMenu->wMaxSizeLruItem);
  70.   if (lpMruMenu->lpMRU == NULL)
  71.      {
  72.        GlobalFreePtr(lpMruMenu);
  73.        lpMruMenu =  NULL;
  74.      }
  75.   return lpMruMenu;
  76. }
  77.  
  78. //*************************************************************
  79. //
  80. //  CreateMruMenuDefault()
  81. //
  82. //  Purpose:
  83. //
  84. //              Allocate and Initialize an MRU and return a pointer on it
  85. //              Use default parameter
  86. //
  87. //
  88. //  Parameters:
  89. //
  90. //
  91. //  Return: (LPMRUMENU)
  92. //
  93. //      Pointer on a MRUMENU structure, used by other function
  94. //
  95. //
  96. //  Comments:
  97. //
  98. //
  99. //  History:    Date       Author       Comment
  100. //              09/24/94   G. Vollant   Created
  101. //
  102. //*************************************************************
  103.  
  104. LPMRUMENU CreateMruMenuDefault()
  105. {
  106.   return CreateMruMenu (NBMRUMENUSHOW,NBMRUMENU,MAXSIZEMRUITEM,IDMRU);
  107. }
  108.  
  109.  
  110. //*************************************************************
  111. //
  112. //  DeleteMruMenu()
  113. //
  114. //  Purpose:
  115. //              Destructor :
  116. //              Clean and free a MRUMENU structure
  117. //
  118. //  Parameters:
  119. //
  120. //      LPMRUMENU lpMruMenu -      pointer on MRUMENU, allocated
  121. //             by CreateMruMenu() or CreateMruMenuDefault()
  122. //
  123. //
  124. //  Return: void
  125. //
  126. //
  127. //  Comments:
  128. //
  129. //
  130. //  History:    Date       Author       Comment
  131. //              09/24/94   G. Vollant   Created
  132. //
  133. //*************************************************************
  134. void DeleteMruMenu(LPMRUMENU lpMruMenu)
  135. {
  136.   GlobalFreePtr(lpMruMenu->lpMRU);
  137.   GlobalFreePtr(lpMruMenu);
  138. }
  139.  
  140. //*************************************************************
  141. //
  142. //  SetNbLruShow()
  143. //
  144. //  Purpose:
  145. //              Change the maximum number of item displayed on menu
  146. //
  147. //  Parameters:
  148. //      LPMRUMENU lpMruMenu -      pointer on MRUMENU
  149. //      WORD wNbLruShowInit -      Maximum number of item displayed on menu
  150. //
  151. //
  152. //  Return: void
  153. //
  154. //
  155. //  Comments:
  156. //
  157. //
  158. //  History:    Date       Author       Comment
  159. //              09/24/94   G. Vollant   Created
  160. //
  161. //*************************************************************
  162. void SetNbLruShow   (LPMRUMENU lpMruMenu,WORD wNbLruShowInit)
  163. {
  164.   lpMruMenu->wNbLruShow = min(wNbLruShowInit,lpMruMenu->wNbLruMenu);
  165. }
  166.  
  167. //*************************************************************
  168. //
  169. //  SetMenuItem()
  170. //
  171. //  Purpose:
  172. //              Set the filename of an item 
  173. //
  174. //  Parameters:
  175. //      LPMRUMENU lpMruMenu -      pointer on MRUMENU
  176. //      WORD wItem -               Number of Item to set, zero based
  177. //      LPSTR lpItem -             String, contain the filename of the item
  178. //
  179. //
  180. //  Return: (BOOL)
  181. //      TRUE  - Function run successfully
  182. //      FALSE - Function don't run successfully
  183. //
  184. //
  185. //  Comments:
  186. //      used when load .INI or reg database
  187. //
  188. //  History:    Date       Author       Comment
  189. //              09/24/94   G. Vollant   Created
  190. //
  191. //*************************************************************
  192. BOOL SetMenuItem    (LPMRUMENU lpMruMenu,WORD wItem,LPSTR lpItem)
  193. {                                      
  194.   if (wItem >= NBMRUMENU) 
  195.     return FALSE;
  196.   _fstrncpy((lpMruMenu->lpMRU) + 
  197.             ((lpMruMenu->wMaxSizeLruItem) * (UINT)wItem),
  198.             lpItem,lpMruMenu->wMaxSizeLruItem-1);
  199.   lpMruMenu->wNbItemFill = max(lpMruMenu->wNbItemFill,wItem+1);
  200.   return TRUE;
  201. }
  202.  
  203. //*************************************************************
  204. //
  205. //  GetMenuItem()
  206. //
  207. //  Purpose:
  208. //              Get the filename of an item 
  209. //
  210. //  Parameters:
  211. //      LPMRUMENU lpMruMenu -      pointer on MRUMENU
  212. //      WORD wItem -               Number of Item to set, zero based
  213. //      BOOL fIDMBased -           TRUE :  wItem is based on ID menu item
  214. //                                 FALSE : wItem is zero-based
  215. //      LPSTR lpItem -             String where the filename of the item will be
  216. //                                   stored by GetMenuItem()
  217. //      UINT  uiSize -             Size of the lpItem buffer
  218. //
  219. //
  220. //  Return: (BOOL)
  221. //      TRUE  - Function run successfully
  222. //      FALSE - Function don't run successfully
  223. //
  224. //
  225. //  Comments:
  226. //      Used for saving in .INI or reg database, or when user select
  227. //        an MRU in File menu
  228. //
  229. //  History:    Date       Author       Comment
  230. //              09/24/94   G. Vollant   Created
  231. //
  232. //*************************************************************
  233. BOOL GetMenuItem    (LPMRUMENU lpMruMenu,WORD wItem,
  234.                      BOOL fIDMBased,LPSTR lpItem,UINT uiSize)
  235. {
  236.   if (fIDMBased) 
  237.     wItem -= (lpMruMenu->wIdMru + 1);
  238.   if (wItem >= lpMruMenu->wNbItemFill) 
  239.     return FALSE;
  240.   _fstrncpy(lpItem,(lpMruMenu->lpMRU) + 
  241.                 ((lpMruMenu->wMaxSizeLruItem) * (UINT)(wItem)),uiSize);
  242.   *(lpItem+uiSize-1) = '\0';
  243.   return TRUE;
  244. }
  245.  
  246. //*************************************************************
  247. //
  248. //  AddNewItem()
  249. //
  250. //  Purpose:
  251. //              Add an item at the begin of the list
  252. //
  253. //  Parameters:
  254. //      LPMRUMENU lpMruMenu -      pointer on MRUMENU
  255. //      LPSTR lpItem -             String contain the filename to add
  256. //
  257. //  Return: (BOOL)
  258. //      TRUE  - Function run successfully
  259. //      FALSE - Function don't run successfully
  260. //
  261. //
  262. //  Comments:
  263. //      Used when used open a file (using File Open common
  264. //        dialog, Drag and drop or MRU)
  265. //
  266. //  History:    Date       Author       Comment
  267. //              09/24/94   G. Vollant   Created
  268. //
  269. //*************************************************************
  270. void AddNewItem     (LPMRUMENU lpMruMenu,LPSTR lpItem)
  271. {
  272. WORD i,j;
  273.   for (i=0;i<lpMruMenu->wNbItemFill;i++)
  274.     if (lstrcmpi(lpItem,(lpMruMenu->lpMRU) + 
  275.         ((lpMruMenu->wMaxSizeLruItem) * (UINT)i)) == 0)
  276.       {         
  277.         // Shift the other items
  278.         for (j=i;j>0;j--)
  279.          lstrcpy((lpMruMenu->lpMRU) + (lpMruMenu->wMaxSizeLruItem * (UINT)j),
  280.                  (lpMruMenu->lpMRU) + (lpMruMenu->wMaxSizeLruItem * (UINT)(j-1)));
  281.         _fstrncpy(lpMruMenu->lpMRU,lpItem,lpMruMenu->wMaxSizeLruItem-1);  
  282.         return ;
  283.       }
  284.   lpMruMenu->wNbItemFill = min(lpMruMenu->wNbItemFill+1,lpMruMenu->wNbLruMenu);
  285.   for (i=lpMruMenu->wNbItemFill-1;i>0;i--)
  286.      lstrcpy(lpMruMenu->lpMRU + (lpMruMenu->wMaxSizeLruItem * (UINT)i),
  287.              lpMruMenu->lpMRU + (lpMruMenu->wMaxSizeLruItem * (UINT)(i-1)));
  288.   _fstrncpy(lpMruMenu->lpMRU,lpItem,lpMruMenu->wMaxSizeLruItem-1);  
  289. }
  290.  
  291. //*************************************************************
  292. //
  293. //  DelMenuItem()
  294. //
  295. //  Purpose:
  296. //              Delete an item
  297. //
  298. //  Parameters:
  299. //      LPMRUMENU lpMruMenu -      pointer on MRUMENU
  300. //      WORD wItem -               Number of Item to set, zero based
  301. //      BOOL fIDMBased -           TRUE :  wItem is based on ID menu item
  302. //                                 FALSE : wItem is zero-based
  303. //
  304. //  Return: (BOOL)
  305. //      TRUE  - Function run successfully
  306. //      FALSE - Function don't run successfully
  307. //
  308. //
  309. //  Comments:
  310. //      Used when used open a file, using MRU, and when an error
  311. //         occured (by example, when file was deleted)
  312. //
  313. //  History:    Date       Author       Comment
  314. //              09/24/94   G. Vollant   Created
  315. //
  316. //*************************************************************
  317. BOOL DelMenuItem(LPMRUMENU lpMruMenu,WORD wItem,BOOL fIDMBased)
  318. { 
  319. WORD i;
  320.   if (fIDMBased) 
  321.     wItem -= (lpMruMenu->wIdMru + 1);
  322.   if (lpMruMenu->wNbItemFill <= wItem) 
  323.     return FALSE;
  324.   lpMruMenu->wNbItemFill--;
  325.   for (i=wItem;i<lpMruMenu->wNbItemFill;i++)
  326.      lstrcpy(lpMruMenu->lpMRU + (lpMruMenu->wMaxSizeLruItem * (UINT)i),
  327.              lpMruMenu->lpMRU + (lpMruMenu->wMaxSizeLruItem * (UINT)(i+1)));
  328.   return TRUE;
  329. }
  330.                            
  331. //*************************************************************
  332. //
  333. //  PlaceMenuMRUItem()
  334. //
  335. //  Purpose:
  336. //              Add MRU at the end of a menu
  337. //
  338. //  Parameters:
  339. //      LPMRUMENU lpMruMenu -      pointer on MRUMENU
  340. //      HMENU hMenu -              Handle of menu where MRU must be added
  341. //      UINT uiItem -              Item of menu entry where MRU must be added
  342. //
  343. //  Return: void
  344. //
  345. //
  346. //  Comments:
  347. //      Used MRU is modified, for refresh the File menu
  348. //
  349. //  History:    Date       Author       Comment
  350. //              09/24/94   G. Vollant   Created
  351. //
  352. //*************************************************************
  353. void PlaceMenuMRUItem(LPMRUMENU lpMruMenu,HMENU hMenu,UINT uiItem)
  354. {
  355. int  i;   
  356. WORD wNbShow;
  357.   if (hMenu == NULL) 
  358.     return;
  359.   // remove old MRU in menu
  360.   for (i=0;i<=(int)(lpMruMenu->wNbLruMenu);i++)
  361.     RemoveMenu(hMenu,i+lpMruMenu->wIdMru,MF_BYCOMMAND);
  362.  
  363.   if (lpMruMenu->wNbItemFill == 0) 
  364.     return;
  365.  
  366.   // If they are item, insert a separator before the files
  367.   InsertMenu(hMenu,uiItem,MF_SEPARATOR,lpMruMenu->wIdMru,NULL);
  368.  
  369.   wNbShow = min(lpMruMenu->wNbItemFill,lpMruMenu->wNbLruShow);
  370.   for (i=(int)wNbShow-1;i>=0;i--)
  371.   {
  372.   LPSTR lpTxt;
  373.     if (lpTxt = (LPSTR)GlobalAllocPtr(GHND,lpMruMenu->wMaxSizeLruItem + 20))
  374.       {
  375.         wsprintf(lpTxt,"&%lu %s",
  376.                  (DWORD)(i+1),lpMruMenu->lpMRU + (lpMruMenu->wMaxSizeLruItem*(UINT)i));
  377.         InsertMenu(hMenu,(((WORD)i)!=(wNbShow-1)) ? (lpMruMenu->wIdMru+i+2) : lpMruMenu->wIdMru,
  378.                    MF_STRING,lpMruMenu->wIdMru+i+1,lpTxt);   
  379.         GlobalFreePtr(lpTxt);
  380.       }
  381.   }
  382.  
  383. }
  384.  
  385. ///////////////////////////////////////////
  386.  
  387.  
  388.  
  389. //*************************************************************
  390. //
  391. //  SaveMruInIni()
  392. //
  393. //  Purpose:
  394. //              Save MRU in a private .INI
  395. //
  396. //  Parameters:
  397. //      LPMRUMENU lpMruMenu -      pointer on MRUMENU
  398. //      LPSTR lpszSection  -       Points to a null-terminated string containing
  399. //                                      the name of the section 
  400. //      LPSTR lpszFile -           Points to a null-terminated string that names 
  401. //                                      the initialization file. 
  402. //
  403. //  Return: (BOOL)
  404. //      TRUE  - Function run successfully
  405. //      FALSE - Function don't run successfully
  406. //
  407. //
  408. //  Comments:
  409. //      See WritePrivateProfileString API for more info on lpszSection and lpszFile
  410. //
  411. //  History:    Date       Author       Comment
  412. //              09/24/94   G. Vollant   Created
  413. //
  414. //*************************************************************
  415. BOOL SaveMruInIni(LPMRUMENU lpMruMenu,LPSTR lpszSection,LPSTR lpszFile)
  416. {
  417. LPSTR lpTxt;
  418. WORD i;
  419.  
  420.   lpTxt = (LPSTR)GlobalAllocPtr(GHND,lpMruMenu->wMaxSizeLruItem + 20);
  421.   if (lpTxt == NULL) 
  422.     return FALSE;
  423.  
  424.   for (i=0;i<lpMruMenu->wNbLruMenu;i++)
  425.     {
  426.     char szEntry[16];
  427.       wsprintf(szEntry,"File%lu",(DWORD)i+1);
  428.       if (!GetMenuItem(lpMruMenu,i,FALSE,lpTxt,lpMruMenu->wMaxSizeLruItem + 10))
  429.         *lpTxt = '\0';
  430.       WritePrivateProfileString(lpszSection,szEntry,lpTxt,lpszFile);
  431.     }
  432.   GlobalFreePtr(lpTxt);
  433.   WritePrivateProfileString(NULL,NULL,NULL,lpszFile); // flush cache 
  434.   return TRUE;
  435. }
  436.  
  437.  
  438. //*************************************************************
  439. //
  440. //  LoadMruInIni()
  441. //
  442. //  Purpose:
  443. //              Load MRU from a private .INI
  444. //
  445. //  Parameters:
  446. //      LPMRUMENU lpMruMenu -      pointer on MRUMENU
  447. //      LPSTR lpszSection  -       Points to a null-terminated string containing
  448. //                                      the name of the section 
  449. //      LPSTR lpszFile -           Points to a null-terminated string that names 
  450. //                                      the initialization file. 
  451. //
  452. //  Return: (BOOL)
  453. //      TRUE  - Function run successfully
  454. //      FALSE - Function don't run successfully
  455. //
  456. //
  457. //  Comments:
  458. //      See GetPrivateProfileString API for more info on lpszSection and lpszFile
  459. //
  460. //  History:    Date       Author       Comment
  461. //              09/24/94   G. Vollant   Created
  462. //
  463. //*************************************************************
  464. BOOL LoadMruInIni(LPMRUMENU lpMruMenu,LPSTR lpszSection,LPSTR lpszFile)
  465. {
  466. LPSTR lpTxt;
  467. WORD i;
  468.   lpTxt = (LPSTR)GlobalAllocPtr(GHND,lpMruMenu->wMaxSizeLruItem + 20);
  469.   if (lpTxt == NULL) 
  470.     return FALSE;
  471.  
  472.   for (i=0;i<lpMruMenu->wNbLruMenu;i++)
  473.     {
  474.     char szEntry[16];
  475.       
  476.       wsprintf(szEntry,"File%lu",(DWORD)i+1);
  477.       GetPrivateProfileString(lpszSection,szEntry,"",lpTxt,
  478.                               lpMruMenu->wMaxSizeLruItem + 10,lpszFile);
  479.       if (*lpTxt == '\0')
  480.         break;
  481.       SetMenuItem(lpMruMenu,i,lpTxt);
  482.     }
  483.   GlobalFreePtr(lpTxt);
  484.   return TRUE;
  485. }
  486.  
  487. #ifdef WIN32
  488.  
  489. BOOL IsWin395OrHigher(void)
  490. {
  491.   WORD wVer;
  492.  
  493.   wVer = LOWORD(GetVersion());
  494.   wVer = (((WORD)LOBYTE(wVer)) << 8) | (WORD)HIBYTE(wVer);
  495.  
  496.   return (wVer >= 0x035F);              // 5F = 95 dec
  497. }
  498.  
  499.  
  500. //*************************************************************
  501. //
  502. //  SaveMruInReg()
  503. //
  504. //  Purpose:
  505. //              Save MRU in the registry
  506. //
  507. //  Parameters:
  508. //      LPMRUMENU lpMruMenu -      pointer on MRUMENU
  509. //      LPSTR lpszKey  -           Points to a null-terminated string 
  510. //                                      specifying  the name of a key that 
  511. //                                      this function opens or creates.
  512. //
  513. //  Return: (BOOL)
  514. //      TRUE  - Function run successfully
  515. //      FALSE - Function don't run successfully
  516. //
  517. //
  518. //  Comments:
  519. //      Win32 function designed for Windows NT and Windows 95
  520. //      See RegCreateKeyEx API for more info on lpszKey
  521. //
  522. //  History:    Date       Author       Comment
  523. //              09/24/94   G. Vollant   Created
  524. //
  525. //*************************************************************
  526. BOOL SaveMruInReg(LPMRUMENU lpMruMenu,LPSTR lpszKey)
  527. {
  528. LPSTR lpTxt;
  529. WORD i;
  530. HKEY hCurKey;
  531. DWORD dwDisp;
  532.  
  533.   lpTxt = (LPSTR)GlobalAllocPtr(GHND,lpMruMenu->wMaxSizeLruItem + 20);
  534.   if (lpTxt == NULL) 
  535.     return FALSE;
  536.  
  537.   RegCreateKeyEx(HKEY_CURRENT_USER,lpszKey,0,NULL,
  538.                   REG_OPTION_NON_VOLATILE,KEY_ALL_ACCESS,NULL,&hCurKey,&dwDisp);
  539.  
  540.   for (i=0;i<lpMruMenu->wNbLruMenu;i++)
  541.     {
  542.     char szEntry[16];
  543.       wsprintf(szEntry,"File%lu",(DWORD)i+1);
  544.       if (!GetMenuItem(lpMruMenu,i,FALSE,lpTxt,lpMruMenu->wMaxSizeLruItem + 10))
  545.         *lpTxt = '\0';
  546.       RegSetValueEx(hCurKey,szEntry,0,REG_SZ,(unsigned char*)lpTxt,lstrlen(lpTxt));
  547.     }
  548.   RegCloseKey(hCurKey);
  549.   GlobalFreePtr(lpTxt);
  550.   return TRUE;
  551. }
  552.  
  553. //*************************************************************
  554. //
  555. //  LoadMruInReg()
  556. //
  557. //  Purpose:
  558. //              Load MRU from the registry
  559. //
  560. //  Parameters:
  561. //      LPMRUMENU lpMruMenu -      pointer on MRUMENU
  562. //      LPSTR lpszKey  -           Points to a null-terminated string 
  563. //                                      specifying  the name of a key that 
  564. //                                      this function opens or creates.
  565. //
  566. //  Return: (BOOL)
  567. //      TRUE  - Function run successfully
  568. //      FALSE - Function don't run successfully
  569. //
  570. //
  571. //  Comments:
  572. //      Win32 function designed for Windows NT and Windows 95
  573. //      See RegOpenKeyEx API for more info on lpszKey
  574. //
  575. //  History:    Date       Author       Comment
  576. //              09/24/94   G. Vollant   Created
  577. //
  578. //*************************************************************
  579. BOOL LoadMruInReg(LPMRUMENU lpMruMenu,LPSTR lpszKey)
  580. {
  581. LPSTR lpTxt;
  582. WORD i;
  583. HKEY hCurKey;
  584. DWORD dwType;
  585.   lpTxt = (LPSTR)GlobalAllocPtr(GHND,lpMruMenu->wMaxSizeLruItem + 20);
  586.   if (lpTxt == NULL) 
  587.     return FALSE;
  588.  
  589.   RegOpenKeyEx(HKEY_CURRENT_USER,lpszKey,0,KEY_READ,&hCurKey);
  590.  
  591.  
  592.   for (i=0;i<lpMruMenu->wNbLruMenu;i++)
  593.     {
  594.     char szEntry[16];
  595.     DWORD dwSizeBuf;  
  596.       wsprintf(szEntry,"File%lu",(DWORD)i+1);
  597.       *lpTxt = '\0';
  598.       dwSizeBuf = lpMruMenu->wMaxSizeLruItem + 10;
  599.       RegQueryValueEx(hCurKey,szEntry,NULL,&dwType,(LPBYTE)lpTxt,&dwSizeBuf);
  600.       *(lpTxt+dwSizeBuf)='\0';
  601.       if (*lpTxt == '\0')
  602.         break;
  603.       SetMenuItem(lpMruMenu,i,lpTxt);
  604.     }
  605.   RegCloseKey(hCurKey);
  606.   GlobalFreePtr(lpTxt);
  607.   return TRUE;
  608. }
  609.  
  610.  
  611. //*************************************************************
  612. //
  613. //  GetWin32Kind()
  614. //
  615. //  Purpose:
  616. //              Get the Win32 platform
  617. //
  618. //  Parameters:
  619. //
  620. //  Return: (WIN32KIND)
  621. //      WINNT -           Run under Windows NT
  622. //      WIN32S -          Run under Windows 3.1x + Win32s
  623. //      WIN95ORGREATHER - Run under Windows 95
  624. //
  625. //
  626. //  Comments:
  627. //      Win32 function designed for Windows NT and Windows 95
  628. //      See RegOpenKeyEx API for more info on lpszKey
  629. //
  630. //  History:    Date       Author       Comment
  631. //              09/24/94   G. Vollant   Created
  632. //
  633. //*************************************************************
  634. WIN32KIND GetWin32Kind()
  635. {
  636. BOOL IsWin395OrHigher(void);
  637.  
  638.   WORD wVer;
  639.  
  640.   if ((GetVersion() & 0x80000000) == 0)
  641.     return WINNT;
  642.   wVer = LOWORD(GetVersion());
  643.   wVer = (((WORD)LOBYTE(wVer)) << 8) | (WORD)HIBYTE(wVer);
  644.  
  645.   if (wVer >= 0x035F)
  646.     return WIN95ORGREATHER;
  647.   else
  648.     return WIN32S;
  649. }
  650. #endif
  651.